const { PrismaClient } = require('@prisma/client');
const prisma = new PrismaClient();


// 获取所有商品
exports.getAllProducts = async (req, res) => {
  try {
    const { page = 1, limit = 50, categoryId, search, status } = req.query;
    const skip = (page - 1) * limit;
    
    // 构建过滤条件
    const where = {};
    if (categoryId) where.categoryId = Number(categoryId);
    if (status !== undefined) where.status = status === 'true';
    if (search) {
      where.OR = [
        { name: { contains: search } },
        { description: { contains: search } }
      ];
    }
    
    // 查询商品
    const products = await prisma.product.findMany({
      skip,
      take: Number(limit),
      where,
      orderBy: { id: 'asc' }
    });
    
    // 获取商品的分类ID
    const categoryIds = [...new Set(products.filter(p => p.categoryId).map(p => p.categoryId))];
    
    // 单独查询分类信息
    const categories = await prisma.Category.findMany({
      where: {
        id: {
          in: categoryIds
        }
      }
    });
    
    // 创建分类查找映射
    const categoryMap = categories.reduce((map, category) => {
      map[category.id] = category;
      return map;
    }, {});
    
    // 组合商品和分类信息
    const productsWithCategory = products.map(product => ({
      ...product,
      category: product.categoryId ? categoryMap[product.categoryId] : null
    }));
    
    // 获取总数
    const total = await prisma.product.count({ where });
    
    res.json({
      status: 'success',
      data: productsWithCategory,
      meta: {
        total,
        page: Number(page),
        limit: Number(limit),
        pages: Math.ceil(total / limit)
      }
    });
  } catch (error) {
    console.error('获取商品失败:', error);
    res.status(500).json({
      status: 'error',
      message: '获取商品失败',
      error: error.message
    });
  }
};

// 获取单个商品
exports.getProductById = async (req, res) => {
  try {
    const { id } = req.params;
    
    // 查询商品
    const product = await prisma.product.findUnique({
      where: { id: Number(id) }
    });
    
    if (!product) {
      return res.status(404).json({
        status: 'error',
        message: '商品不存在'
      });
    }
    
    // 单独查询分类
    let category = null;
    if (product.categoryId) {
      category = await prisma.Category.findUnique({
        where: { id: product.categoryId }
      });
    }
    
    // 组合商品和分类信息
    const productWithCategory = {
      ...product,
      category
    };
    
    res.json({
      status: 'success',
      data: productWithCategory
    });
  } catch (error) {
    console.error('获取商品详情失败:', error);
    res.status(500).json({
      status: 'error',
      message: '获取商品详情失败',
      error: error.message
    });
  }
};

// 创建商品
exports.createProduct = async (req, res) => {
  try {
    const { name, description, price, categoryId, imageUrl } = req.body;
    
    // 验证数据
    if (!name || !price || !categoryId) {
      return res.status(400).json({
        status: 'error',
        message: '商品名称、价格和分类为必填项'
      });
    }
    
    // 创建商品
    const product = await prisma.product.create({
      data: {
        name,
        description,
        price: Number(price),
        categoryId: Number(categoryId),
        imageUrl,
        status: true
      }
    });
    

    
    res.status(201).json({
      status: 'success',
      message: '商品创建成功',
      data: product
    });
  } catch (error) {
    console.error('创建商品失败:', error);
    res.status(500).json({
      status: 'error',
      message: '创建商品失败',
      error: error.message
    });
  }
};

// 更新商品
exports.updateProduct = async (req, res) => {
  try {
    const { id } = req.params;
    const { name, description, price, categoryId, imageUrl, status } = req.body;
    
    // 验证商品是否存在
    const existingProduct = await prisma.product.findUnique({
      where: { id: Number(id) }
    });
    
    if (!existingProduct) {
      return res.status(404).json({
        status: 'error',
        message: '商品不存在'
      });
    }
    
    // 更新商品
    const product = await prisma.product.update({
      where: { id: Number(id) },
      data: {
        name: name !== undefined ? name : existingProduct.name,
        description: description !== undefined ? description : existingProduct.description,
        price: price !== undefined ? Number(price) : existingProduct.price,
        categoryId: categoryId !== undefined ? Number(categoryId) : existingProduct.categoryId,
        imageUrl: imageUrl !== undefined ? imageUrl : existingProduct.imageUrl,
        status: status !== undefined ? status : existingProduct.status
      }
    });
    
    // 记录审计日志
    await logUserAction({
      userId: req.user.id,
      action: 'update',
      module: 'products',
      description: `更新商品: ${name}`,
      details: { 
        productId: product.id, 
        productName: name,
        changes: {
          from: {
            name: existingProduct.name,
            price: existingProduct.price,
            categoryId: existingProduct.categoryId,
            status: existingProduct.status
          },
          to: {
            name,
            price: Number(price),
            categoryId: Number(categoryId),
            status: status === undefined ? existingProduct.status : status
          }
        }
      },
      ip: req.ip || req.connection.remoteAddress,
      userAgent: req.headers['user-agent']
    });
    
    res.json({
      status: 'success',
      message: '商品更新成功',
      data: product
    });
  } catch (error) {
    console.error('更新商品失败:', error);
    res.status(500).json({
      status: 'error',
      message: '更新商品失败',
      error: error.message
    });
  }
};

// 删除商品
exports.deleteProduct = async (req, res) => {
  try {
    const { id } = req.params;
    const productId = Number(id);
    
    console.log(`尝试删除商品 ID: ${productId}`);
    
    // 验证商品是否存在
    const existingProduct = await prisma.product.findUnique({
      where: { id: productId }
    });
    
    if (!existingProduct) {
      console.log(`商品不存在 ID: ${productId}`);
      return res.status(404).json({
        status: 'error',
        message: '商品不存在'
      });
    }
    
    // 检查是否有关联的订单项
    const orderItems = await prisma.orderItem.findMany({
      where: { productId: productId }
    });
    
    // 检查是否有关联的价格策略
    const productPrices = await prisma.productPrice.findMany({
      where: { productId: productId }
    });
    
    // 如果有关联数据，先删除关联数据
    if (orderItems.length > 0 || productPrices.length > 0) {
      console.log(`商品存在关联数据，准备删除关联数据：订单项 ${orderItems.length} 条，价格策略 ${productPrices.length} 条`);
      
      // 开始事务
      await prisma.$transaction(async (prisma) => {
        // 删除关联的价格策略
        if (productPrices.length > 0) {
          await prisma.productPrice.deleteMany({
            where: { productId: productId }
          });
          console.log(`已删除关联的价格策略 ${productPrices.length} 条`);
        }
        
        // 删除关联的订单项
        if (orderItems.length > 0) {
          // 找到包含此商品的所有订单
          const orderIds = [...new Set(orderItems.map(item => item.orderId))];
          console.log(`关联的订单 ID: ${orderIds.join(', ')}`);
          
          // 对于包含此商品的订单，更新总价
          for (const orderId of orderIds) {
            // 获取订单的所有商品项
            const items = await prisma.orderItem.findMany({
              where: { orderId: orderId }
            });
            
            // 如果订单只有这一个商品，将订单标记为已取消
            if (items.length === 1 && items[0].productId === productId) {
              await prisma.order.update({
                where: { id: orderId },
                data: { status: 'cancelled' }
              });
              console.log(`订单 ${orderId} 只有此商品，已标记为已取消`);
            } else {
              // 计算新的总价
              const newTotal = items
                .filter(item => item.productId !== productId)
                .reduce((sum, item) => sum + item.price * item.quantity, 0);
              
              // 更新订单总价
              await prisma.order.update({
                where: { id: orderId },
                data: { total: newTotal }
              });
              console.log(`已更新订单 ${orderId} 的总价为 ${newTotal}`);
            }
          }
          
          // 删除所有关联的订单项
          await prisma.orderItem.deleteMany({
            where: { productId: productId }
          });
          console.log(`已删除关联的订单项 ${orderItems.length} 条`);
        }
        
        // 最后删除商品
        await prisma.product.delete({
          where: { id: productId }
        });
        console.log(`成功删除商品 ID: ${productId}`);
      });
      
      // 记录审计日志
      await logUserAction({
        userId: req.user.id,
        action: 'delete',
        module: 'products',
        description: `删除商品: ${existingProduct.name}`,
        details: { productId: productId, productName: existingProduct.name },
        ip: req.ip || req.connection.remoteAddress,
        userAgent: req.headers['user-agent']
      });
      
      return res.json({
        status: 'success',
        message: '商品及其关联数据删除成功'
      });
    } else {
      // 如果没有关联数据，直接删除商品
      console.log(`商品无关联数据，直接删除`);
      await prisma.product.delete({
        where: { id: productId }
      });
      
      console.log(`成功删除商品 ID: ${productId}`);
      

      
      return res.json({
        status: 'success',
        message: '商品删除成功'
      });
    }
  } catch (error) {
    console.error('删除商品失败:', error);
    return res.status(500).json({
      status: 'error',
      message: '删除商品失败: ' + error.message
    });
  }
};

// 获取所有商品渠道价格
exports.getAllProductChannelPrices = async (req, res) => {
  try {
    const productPrices = await prisma.productPrice.findMany({
      include: {
        product: true,
        channel: true
      }
    });
    
    res.json({
      status: 'success',
      data: productPrices
    });
  } catch (error) {
    console.error('获取商品渠道价格失败:', error);
    res.status(500).json({
      status: 'error',
      message: '获取商品渠道价格失败',
      error: error.message
    });
  }
};

// 获取单个商品的渠道价格
exports.getProductChannelPrices = async (req, res) => {
  try {
    const { id } = req.params;
    const productId = Number(id);
    
    // 验证商品是否存在
    const product = await prisma.product.findUnique({
      where: { id: productId }
    });
    
    if (!product) {
      return res.status(404).json({
        status: 'error',
        message: '商品不存在'
      });
    }
    
    const prices = await prisma.productPrice.findMany({
      where: { productId },
      include: {
        channel: true
      }
    });
    
    res.json({
      status: 'success',
      data: prices
    });
  } catch (error) {
    console.error('获取商品渠道价格失败:', error);
    res.status(500).json({
      status: 'error',
      message: '获取商品渠道价格失败',
      error: error.message
    });
  }
};

// 设置商品渠道价格
exports.setProductChannelPrices = async (req, res) => {
  try {
    const { id } = req.params;
    const productId = Number(id);
    const { prices } = req.body;
    
    // 验证数据
    if (!prices || !Array.isArray(prices)) {
      return res.status(400).json({
        status: 'error',
        message: 'prices必须是一个数组'
      });
    }
    
    // 验证商品是否存在
    const product = await prisma.product.findUnique({
      where: { id: productId }
    });
    
    if (!product) {
      return res.status(404).json({
        status: 'error',
        message: '商品不存在'
      });
    }
    
    // 开始事务
    const results = await prisma.$transaction(async (prisma) => {
      const updated = [];
      
      for (const price of prices) {
        const { channelId, price: priceValue } = price;
        
        if (!channelId || priceValue === undefined) {
          continue;
        }
        
        // 查询是否已存在价格
        const existingPrice = await prisma.productPrice.findFirst({
          where: {
            productId,
            channelId: Number(channelId)
          }
        });
        
        if (existingPrice) {
          // 更新价格
          const updatedPrice = await prisma.productPrice.update({
            where: { id: existingPrice.id },
            data: { price: Number(priceValue) }
          });
          updated.push(updatedPrice);
        } else {
          // 创建价格
          const newPrice = await prisma.productPrice.create({
            data: {
              productId,
              channelId: Number(channelId),
              price: Number(priceValue)
            }
          });
          updated.push(newPrice);
        }
      }
      
      return updated;
    });
    
    res.json({
      status: 'success',
      message: '商品渠道价格设置成功',
      data: results
    });
  } catch (error) {
    console.error('设置商品渠道价格失败:', error);
    res.status(500).json({
      status: 'error',
      message: '设置商品渠道价格失败',
      error: error.message
    });
  }
}; 